// 工具函数

/**
 * 延迟执行函数
 * @param {number} ms - 延迟毫秒数
 * @returns {Promise} 
 */
export const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

/**
 * 格式化时间
 * @param {number} milliseconds - 毫秒数
 * @returns {string} 格式化后的时间字符串
 */
export const formatTime = (milliseconds) => {
  const seconds = Math.floor(milliseconds / 1000);
  const minutes = Math.floor(seconds / 60);
  const hours = Math.floor(minutes / 60);
  
  if (hours > 0) {
    return `${hours}小时${minutes % 60}分钟`;
  } else if (minutes > 0) {
    return `${minutes}分钟${seconds % 60}秒`;
  } else {
    return `${seconds}秒`;
  }
};

/**
 * 格式化日期
 * @param {Date} date - 日期对象
 * @returns {string} 格式化后的日期字符串
 */
export const formatDate = (date) => {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  
  return `${year}-${month}-${day}`;
};

/**
 * 获取今日日期字符串
 * @returns {string} 今日日期字符串
 */
export const getTodayString = () => {
  return formatDate(new Date());
};

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
export const generateUniqueId = () => {
  return Date.now().toString(36) + Math.random().toString(36).substr(2);
};

/**
 * 检查对象是否为空
 * @param {Object} obj - 要检查的对象
 * @returns {boolean} 是否为空
 */
export const isEmptyObject = (obj) => {
  return obj && Object.keys(obj).length === 0 && obj.constructor === Object;
};

/**
 * 深度克隆对象
 * @param {Object} obj - 要克隆的对象
 * @returns {Object} 克隆后的对象
 */
export const deepClone = (obj) => {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  
  const clonedObj = {};
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      clonedObj[key] = deepClone(obj[key]);
    }
  }
  return clonedObj;
};

/**
 * 防抖函数
 * @param {Function} func - 要执行的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export const debounce = (func, wait) => {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
};

/**
 * 节流函数
 * @param {Function} func - 要执行的函数
 * @param {number} limit - 时间限制（毫秒）
 * @returns {Function} 节流后的函数
 */
export const throttle = (func, limit) => {
  let inThrottle;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
};

/**
 * 计算两点间距离
 * @param {number} x1 - 起点X坐标
 * @param {number} y1 - 起点Y坐标
 * @param {number} x2 - 终点X坐标
 * @param {number} y2 - 终点Y坐标
 * @returns {number} 距离
 */
export const calculateDistance = (x1, y1, x2, y2) => {
  const dx = x2 - x1;
  const dy = y2 - y1;
  return Math.sqrt(dx * dx + dy * dy);
};

/**
 * 检查点是否在区域内
 * @param {number} x - 点的X坐标
 * @param {number} y - 点的Y坐标
 * @param {Object} region - 区域对象 {x, y, width, height}
 * @returns {boolean} 是否在区域内
 */
export const isPointInRegion = (x, y, region) => {
  return x >= region.x && x <= region.x + region.width &&
         y >= region.y && y <= region.y + region.height;
};

/**
 * 检查滑动路径是否与广告区域冲突
 * @param {Object} start - 起点坐标 {x, y}
 * @param {Object} end - 终点坐标 {x, y}
 * @param {Array} avoidRegions - 需要避让的区域数组
 * @returns {boolean} 是否冲突
 */
export const checkSwipeCollision = (start, end, avoidRegions) => {
  // 简化的碰撞检测：检查起点或终点是否在避让区域内
  for (const region of avoidRegions) {
    if (isPointInRegion(start.x, start.y, region) || 
        isPointInRegion(end.x, end.y, region)) {
      return true;
    }
  }
  return false;
};

/**
 * 调整滑动坐标以避开广告区域
 * @param {Object} coordinates - 原始坐标 {startX, startY, endX, endY}
 * @param {Array} avoidRegions - 需要避让的区域数组
 * @param {Object} screenSize - 屏幕尺寸 {width, height}
 * @returns {Object} 调整后的坐标
 */
export const adjustCoordinatesForAds = (coordinates, avoidRegions, screenSize) => {
  let adjusted = { ...coordinates };
  
  // 如果起点在避让区域内，调整起点位置
  for (const region of avoidRegions) {
    if (isPointInRegion(adjusted.startX, adjusted.startY, region)) {
      // 将起点移到区域外
      adjusted.startY = region.y + region.height + 0.1;
    }
    
    if (isPointInRegion(adjusted.endX, adjusted.endY, region)) {
      // 将终点移到区域外
      adjusted.endY = region.y - 0.1;
    }
  }
  
  return adjusted;
};

/**
 * 性能监控
 * @returns {Object} 性能指标
 */
export const getPerformanceMetrics = () => {
  const memoryUsage = process.memoryUsage();
  
  return {
    heapUsed: memoryUsage.heapUsed,
    heapTotal: memoryUsage.heapTotal,
    rss: memoryUsage.rss,
    external: memoryUsage.external
  };
};

/**
 * 检查性能是否超标
 * @returns {boolean} 是否超标
 */
export const isPerformanceExceeded = () => {
  const metrics = getPerformanceMetrics();
  const maxMemory = 50 * 1024 * 1024; // 50MB
  
  return metrics.heapUsed > maxMemory;
};

/**
 * 安全执行函数，捕获错误
 * @param {Function} func - 要执行的函数
 * @param {string} context - 上下文信息
 * @returns {*} 执行结果
 */
export const safeExecute = async (func, context = '') => {
  try {
    return await func();
  } catch (error) {
    console.error(`执行失败 [${context}]:`, error);
    return null;
  }
};

/**
 * 延迟执行并检查取消状态
 * @param {number} ms - 延迟毫秒数
 * @param {Function} shouldCancel - 取消检查函数
 * @returns {Promise<boolean>} 是否被取消
 */
export const sleepWithCancel = async (ms, shouldCancel) => {
  const startTime = Date.now();
  
  while (Date.now() - startTime < ms) {
    if (shouldCancel && shouldCancel()) {
      return true; // 被取消
    }
    await sleep(100); // 每100ms检查一次
  }
  
  return false; // 正常完成
};